1. Field of the Invention
The present invention generally relates to computer systems. More particularly, the present invention provides a method, system, and computer program product for providing access to J2EE application servers from non-J2EE application clients.
2. Related Art
The Java 2 Enterprise Edition (J2EE) framework provides many conveniences for application programmers such as transparent end-to-end security and seamless transaction support. However, one problem that adopters of the J2EE framework face is that in order for a distributed application to function correctly, each part of the application must have access to the context objects that are necessary to run within the framework. Examples of such context objects are security context, transaction context, and directory lookup (Java Naming and Directory (JNDI)) context. This requirement is not a problem for the server portion of the application because it is running within a J2EE container such as Websphere (available from IBM) where those context objects are provided natively. But the “remote” parts of the application such as an endpoint monitor or event emitter must obtain these context objects by running in a J2EE application client. These remote parts of the application are often not well-suited to run as an application client for many reasons, including, for example:    (A) The memory and CPU footprints of the application client container are too large;    (B) Java code is required;    (C) The communication protocol (Java Remote Method Invocation technology run over Internet Inter-Orb Protocol (RMI/IIOP)) is not firewall friendly; and    (D) Platform support issues—not every client platform is supported (especially mobile devices).
Several known solutions exist for this problem. In a first solution, the application runs in a “thin” client. The thin application client provides a lightweight, downloadable Java application run time capable of interacting with Enterprise Java Beans (EJBs). This client is designed to support those users who want a lightweight Java client application programming environment, without the overhead of the J2EE platform on the client machine. The programming model for this client is heavily influenced by the CORBA programming model, but supports access to EJBs. This solution suffers from several drawbacks including, for example:    (A) It only addresses the problem of large CPU and memory footprints.    (B) Java code is still required; and    (B) It is not firewall friendly.
In another known solution for the above-described problem, the server provides Web services. As known in the art, Web services is a technology that allows applications to communicate with each other in a platform and programming language independent manner. A Web service is a software interface that describes a collection of operations that can be accessed over a network through standardized Extensible Markup Language (XML) messaging. It uses protocols based on the XML language to describe an operation to execute or data to exchange with another Web service. This solution suffers from several drawbacks including, for example:    (A) Creates a performance bottle-neck. Not suited for bulk data transfers or high traffic communication; and    (B) Security and transaction support are very limited and are far from the level of sophistication provided by J2EE.